package com.fido.kingkongview.utils

/**
 * @author: FiDo
 * @date: 2024/7/23
 * @des:
 */
object HandleDataUtils {


    /**
     * 重新排列数据，使数据转换成分页模式
     * 原始数据：
     * 1 3 5 7 9   11 13 15
     * 2 4 6 8 10  12 14 16
     * ==============================
     * 转换之后：（数据会增加null值）
     * 1 2 3 4 5   11 12 13 14 15
     * 6 7 8 9 10  16 null...
     */
    fun <T> rearrange(data: List<T?>,lines:Int,spanCount:Int): List<T?> {
        if (lines <= 1) return data
        if (data == null || data.isEmpty()) return data
        val pageSize: Int = lines * spanCount
        val size = data.size
        //如果数据少于一行
        if (size <= spanCount) {
            return ArrayList<T?>(data)
        }
        val destList: MutableList<T?> = ArrayList()
        //转换后的总数量，包括空数据
        val sizeAfterTransform = if (size < pageSize) {
            // sizeAfterTransform = pageSize;
            if (size < spanCount) size * lines else pageSize
        } else if (size % pageSize == 0) {
            size
        } else {
            // sizeAfterTransform = (size / pageSize + 1) * pageSize;
            if (size % pageSize < spanCount) size / pageSize * pageSize + size % pageSize * lines else (size / pageSize + 1) * pageSize
        }
        //类似置换矩阵
        for (i in 0 until sizeAfterTransform) {
            val pageIndex = i / pageSize
            val columnIndex: Int = (i - pageSize * pageIndex) / lines
            val rowIndex: Int = (i - pageSize * pageIndex) % lines
            val destIndex: Int = rowIndex * spanCount + columnIndex + pageIndex * pageSize
            if (destIndex >= 0 && destIndex < size) {
                destList.add(data[destIndex])
            } else {
                destList.add(null)
            }
        }
        return destList
    }


    /**
     * 将原数组根据模数进行分组
     *  arrayOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20)
     * Group 0: [3, 6, 9, 12, 15, 18]
     * Group 1: [1, 4, 7, 10, 13, 16, 19]
     * Group 2: [2, 5, 8, 11, 14, 17, 20]
     */
    fun<T> groupListByMod(data:List<T>,mod:Int): List<MutableList<T>> {
        // 创建一个可变列表的列表，大小为mod，来存储结果
        val result = List(mod) { mutableListOf<T>() }
        // 遍历数据数组，根据取模结果将元素添加到相应的子数组中
        data.forEachIndexed { index, t ->
            val i = index % mod
            result[i].add(t)
        }
        return result
    }

    fun<T> groupListIndexByMod(data:List<T>,mod:Int): List<MutableList<Int>> {
        // 创建一个可变列表的列表，大小为mod，来存储结果
        val result = List(mod) { mutableListOf<Int>() }
        // 遍历数据数组，根据取模结果将元素添加到相应的子数组中
        data.forEachIndexed { index, t ->
            val i = index % mod
            result[i].add(index)
        }
        return result
    }

}